
/**
 * fun desc 获取图片信息,保存网络图片时需要先校验域名再获取图片信息
 * @param {String} imgUrl 网络图片地址
 * return {Object} image 图片信息 
 */
export function getImgInfo(imgUrl){
    return new Promise((resolve, reject) => {
        uni.getImageInfo({
            src: imgUrl,
            success: function(image) {
                resolve(image);
            },
            fail(err) {
                reject(err);
            }
        })
    })
}

/**
 * fun desc canvas绘制文字内容
 * @params ctx
 * @params content {String} 文字内容
 * @params size {Number} 字体大小
 * @params lineHeight {Numer} 行高
 * @params color {String} 字体颜色
 * @params align {String} 对齐方式
 * @params x {Number} x坐标
 * @params y {Number} y坐标
 * @params maxWidth {Number} 最大宽度
 * @params maxLine {Number} 最大行数
 * @params noWrap {Number} 是否换行
 * return {Number} Y坐标
 * */
export function drawContent(ctx, content, size, lineHeight=0.2, color, align, x, y, maxWidth, maxLine=1, noWrap=false) {
    let strWidth = 0;
    let strHeight = y;
    let strIndex = 0;
    let lineNum = 1;
    if(content.length == 0) return 0;
    ctx.setTextAlign(align);
    ctx.setFontSize(size);
    ctx.setFillStyle(color);
    for (let i = 0; i < content.length; i++) {
        strWidth += ctx.measureText(content[i]).width;
        if (strWidth > maxWidth) {
            if(maxLine == lineNum && noWrap){
                //文字换行数量大于3进行省略号处理
                ctx.fillText(content.substring(strIndex, i-2)+'...', x, strHeight);
                strWidth = 0;
                strHeight += (size+size*lineHeight);
                strIndex = i;
                lineNum++
                break;
            }else{
                ctx.fillText(content.substring(strIndex, i), x, strHeight);
                strWidth = 0;
                strHeight += (size+size*lineHeight);
                strIndex = i;
                lineNum++
            }
        }
        if (i == content.length - 1) {
            ctx.fillText(content.substring(strIndex, i + 1), x, strHeight);
            strWidth = 0;
            strHeight += (size+size*lineHeight);
            lineNum++
        }
    }
    return strHeight
}

/**
 * 单行文字超出隐藏
 * @param ctx
 * @param {String} str 文本
 * @param {Number} maxWidth 最大宽度
 * @param {Boolean} showEllipsis 是否显示...
*/
export function cavTxtHidden(ctx, str, maxWidth, showEllipsis=true) {
	let strWidth = ctx.measureText(str).width;
	const ellipsis = showEllipsis?'...':'';
	const ellipsisWidth = uni.upx2px(ctx.measureText(ellipsis).width);

	if(strWidth <= maxWidth || maxWidth <= ellipsisWidth) return str;

	let len = str.length;
	while(strWidth >= maxWidth - ellipsisWidth && len-- > 0) {
		str = str.slice(0, len);
		strWidth = ctx.measureText(str).width;
	}
	return str + ellipsis
}

/**
 * fun desc 绘制圆角图片图片
 * @param ctx
 * @param imageInfo {Object} 图片对象
 * @param cx {Number} canvas的X坐标
 * @param cy {Number} canvas的Y坐标
 * @param cw {Number} 绘制路径宽度/绘制在canvas上的图片宽度
 * @param ch {Number} 绘制路径的高度或绘制在canvas上的图片高度
 * @param r {Number} 圆角半径
 * @param x {Number} 裁剪的图片对象X坐标
 * @param y {Number} 裁剪的图片对象Y坐标
 * @param color {String} 路径颜色
 * 
 */
export function drawRadiusImage(ctx, imageInfo, cx, cy, cw, ch, r, x=0, y=0, color='#FFFFFF') {
    // 容错处理，避免 imageInfo 未定义或属性缺失时报错
    if (!imageInfo || !imageInfo.path || !imageInfo.width || !imageInfo.height) {
        // 可以选择直接返回，或者绘制一个占位图形
        // 这里选择直接返回
        return;
    }
    if(cw < 2 * r) {r = cw / 2};
    if(ch < 2 * r) {r = ch / 2};
    ctx.save();
    ctx.beginPath();
    ctx.arc(cx+r, cy+r, r, 0, 2*Math.PI);
    ctx.closePath();
    ctx.strokeStyle = color;
    ctx.stroke();
    ctx.clip();
    // 计算目标高度，防止 imageInfo.width 为 0 导致 NaN
    let drawHeight = ch * imageInfo.width / (cw || 1);
    ctx.drawImage(imageInfo.path, x, y, imageInfo.width, drawHeight, cx, cy, cw, ch);
    ctx.restore();
}

/**
 * fun desc canvas绘制一个有填充色的圆角矩形 
 *@param cxt:canvas的上下文环境 
 *@param x:左上角x轴坐标 
 *@param y:左上角y轴坐标 
 *@param width:矩形的宽度 
 *@param height:矩形的高度 
 *@param radius:圆的半径 
 *@param fillColor:填充颜色 
 **/
export function fillRoundRect(cxt, x, y, width, height, radius, /*optional*/ fillColor) {
    //圆的直径必然要小于矩形的宽高          
    if (2 * radius > width || 2 * radius > height) { return false; }
    cxt.save();
    cxt.translate(x, y);
    //绘制圆角矩形的各个边  
    drawRoundRectPath(cxt, width, height, radius);
    cxt.fillStyle = fillColor || "#000"; //若是给定了值就用给定的值否则给予默认值  
    cxt.fill();
    cxt.restore();
}

/**
 * 绘制圆形并填充颜色
 * @param ctx
 * @param {Number} x坐标
 * @param {Number} y坐标
 * @param {Number} r半径
 * @param {String} color 颜色
 * 
*/
export function drawArcFillStroke(ctx,x,y,r,color) {
    ctx.beginPath();
    ctx.arc(x,y,r,0,2*Math.PI);
    ctx.fillStyle = color;
    ctx.fill();
    ctx.strokeStyle = color;
    ctx.stroke();
}

/**
 *fun desc canvas绘制路径
 */
export function drawRoundRectPath(cxt, width, height, radius) {
    cxt.beginPath(0);
    //从右下角顺时针绘制，弧度从0到1/2PI  
    cxt.arc(width - radius, height - radius, radius, 0, Math.PI / 2);

    //矩形下边线  
    cxt.lineTo(radius, height);

    //左下角圆弧，弧度从1/2PI到PI  
    cxt.arc(radius, height - radius, radius, Math.PI / 2, Math.PI);

    //矩形左边线  
    cxt.lineTo(0, radius);

    //左上角圆弧，弧度从PI到3/2PI  
    cxt.arc(radius, radius, radius, Math.PI, Math.PI * 3 / 2);

    //上边线  
    cxt.lineTo(width - radius, 0);

    //右上角圆弧  
    cxt.arc(width - radius, radius, radius, Math.PI * 3 / 2, Math.PI * 2);

    //右边线  
    cxt.lineTo(width, height - radius);
    cxt.closePath();
}


/**
 * 绘制圆角矩形
 * @param ctx
 * @param x {Number} 圆角X坐标
 * @param y {Number} 圆角Y坐标
 * @param width {Number} 矩形宽度
 * @param height {Number} 矩形高度
 * @param radius {Number} 圆角半径
 * */
export function drawRoundedRect (ctx, x, y, width, height, radius) {
	ctx.beginPath();
    ctx.moveTo(x + radius, y)
    ctx.lineTo(x + width - radius, y)
    ctx.arc(x + width - radius, y + radius, radius, 1.5 * Math.PI, 2 * Math.PI)
    ctx.lineTo(x + width, y + height - radius)
    ctx.arc(x + width - radius, y + height - radius, radius, 0, 0.5 * Math.PI)
    ctx.lineTo(x + radius, y + height)
    ctx.arc(x + radius, y + height - radius, radius, 0.5 * Math.PI, 1 * Math.PI)
    ctx.lineTo(x, y + radius)
    ctx.arc(x + radius, y + radius, radius, 1 * Math.PI, 1.5 * Math.PI)
    ctx.closePath();
}

/**
 * 绘制横线
 * @param context
 * @param {Number} start x开始坐标
 * @param {Number} end x结束坐标
 * @param {Number} yAxis y坐标
 * @param {Number} yAxis y坐标
 * @param {Number} size 线条宽度
 * @param {String} color 颜色
 * 
*/
export function drawLinePath(context, start, end, yAxis, size=1, color) {
	context.beginPath();
    context.moveTo(start, yAxis);
    context.lineTo(end, yAxis);
    context.lineWidth = size;
    context.strokeStyle = color;
    context.stroke();
    context.closePath();
}

/**
 * px转为rpx
*/
export function pxToRpx(px) {
    const screenWidth = uni.getWindowInfo().screenWidth
    return (750 * Number.parseInt(px)) / screenWidth
}

/**
 * fun desc 打开设置列表,查看保存图片授权状态
 */
export function openSettng(){
    uni.showModal({
        content: '请允许保存图片到您相册里,点击确定允许授权',
        success: function(res) {
            if (res.confirm) {
                /* 这个就是打开设置的API*/
                uni.openSetting({
                    success(res) {
                    }
                });
            } else if (res.cancel) {
                uni.showModal({
                    cancelText: '依然取消',
                    confirmText: '重新授权',
                    content: '此操作将取消授权保存图片到本地，请慎重考虑',
                    success: function(res) {
                        if (res.confirm) {
                            uni.openSetting({
                                success(res) {
                                }
                            });
                        } else if (res.cancel) {}
                    }
                })
            }
        }
    });
}